home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / misc / IOBlixDevKitR2.lha / IOBlixDevKit / AutoDocs / ioblixpar.doc < prev    next >
Text File  |  1999-02-01  |  13KB  |  392 lines
  1.  
  2. TABLE OF CONTENTS
  3.  
  4. ioblixpar.device/AllocECPInfo
  5. ioblixpar.device/CMD_CLEAR
  6. ioblixpar.device/CMD_FLUSH
  7. ioblixpar.device/CMD_READ
  8. ioblixpar.device/CMD_RESET
  9. ioblixpar.device/CMD_START
  10. ioblixpar.device/CMD_STOP
  11. ioblixpar.device/CMD_WRITE
  12. ioblixpar.device/FreeECPInfo
  13. ioblixpar.device/GetChipInfo
  14. ioblixpar.device/OpenDevice
  15. ioblixpar.device/PDCMD_QUERY
  16. ioblixpar.device/PDCMD_SETPARAMS
  17.  
  18.  
  19. ioblixpar.device/AllocECPInfo                     ioblixpar.device/AllocECPInfo
  20.  
  21.    NAME
  22.        AllocECPInfo -- get the IEEE1284 probing information
  23.  
  24.    SYNOPSIS
  25.        epi = AllocECPInfo(ioRequest)
  26.        D0                     A0
  27.  
  28.        struct ECPProbeInformation *AllocECPInfo( struct IORequest * );
  29.  
  30.    FUNCTION
  31.        Modern parallel port devices are able to send some information about
  32.        themself back to the controlling machine. These information include
  33.        manufacturer, model, command sets, current state, etc.
  34.        The information block contains all these data in parsed form as well as
  35.        the string that was originally read from the device.
  36.  
  37.    INPUTS
  38.        ioRequest        - pointer to a valid ioRequest after a successfull
  39.                           OpenDevice() call.
  40.  
  41.    RESULTS
  42.        epi  - pointer to struct ECPProbeInformation, or NULL if the call
  43.               failed. if connected device is IEEE1284 compatible then
  44.               epi->epi_IsIEEE1284Compatible will be TRUE and the other fields
  45.               contain all the data that where read from the device.
  46.  
  47.    EXAMPLE
  48.        /* try to get ECP probe information */
  49.        struct IORequest *ioreq;
  50.        struct ECPProbeInformation *epi;
  51.  
  52.        if (!OpenDevice(IOBLIXPAR_NAME, 0, ioreq, 0) {
  53.          if (epi = AllocECPInfo(ioreq)) {
  54.            if (epi->epi_IsIEEE1284Compatible) {
  55.              printf("device %s was manufactured by %s\n",
  56.                     epi->epi_Description, epi->epi_Manufacturer);
  57.            } else {
  58.              printf("no IEEE1284 compatible device found\n");
  59.            }
  60.            FreeECPInfo(epi);
  61.          } else {
  62.            printf("AllocECPInfo() failed\n");
  63.          }
  64.          CloseDevice(ioreq);
  65.        }
  66.  
  67.    SEE ALSO
  68.        FreeECPInfo
  69.  
  70.  
  71. ioblixpar.device/CMD_CLEAR                           ioblixpar.device/CMD_CLEAR
  72.  
  73.    NAME
  74.         Clear -- clear the parallel port buffer
  75.  
  76.    FUNCTION
  77.         This command just RTS's (no buffer to clear)
  78.  
  79.    IO REQUEST
  80.         io_Message      mn_ReplyPort initialized
  81.         io_Device       set by OpenDevice
  82.         io_Unit         set by OpenDevice
  83.         io_Command      CMD_CLEAR (05)
  84.  
  85.  
  86. ioblixpar.device/CMD_FLUSH                           ioblixpar.device/CMD_FLUSH
  87.  
  88.    NAME
  89.         Flush -- clear all queued I/O requests for the parallel port
  90.  
  91.    FUNCTION
  92.         This command purges the read and write request queues for the
  93.         parallel device. The currently active request is not purged.
  94.  
  95.    IO REQUEST
  96.         io_Message      mn_ReplyPort initialized
  97.         io_Device       set by OpenDevice
  98.         io_Unit         set by OpenDevice
  99.         io_Command      CMD_FLUSH (08)
  100.  
  101.  
  102. ioblixpar.device/CMD_READ                             ioblixpar.device/CMD_READ
  103.  
  104.    NAME
  105.         Read -- read input from parallel port
  106.  
  107.    FUNCTION
  108.         This command causes a stream of characters to be read from the
  109.         parallel I/O register. The number of characters is specified in
  110.         io_Length. The EOF and EOL modes are supported, but be warned that
  111.         using these modes can result in a buffer overflow if the proper
  112.         EOL or EOF character is not received in time. These modes should
  113.         be used only when the sender and receiver have been designed to
  114.         cooperate. A safety guard can be implemented to EOF by setting
  115.         io_Length to a maximum allowed value. That cannot be done with EOL
  116.         since the EOL mode is identified by io_Length=-1.
  117.  
  118.         The ioblixpar.device has no internal buffer; if no read request has
  119.         been made, pending input (i.e. handshake request) is not
  120.         acknowledged.
  121.  
  122.    IO REQUEST
  123.         io_Message      mn_ReplyPort initialized
  124.         io_Device       set by OpenDevice
  125.         io_Unit         set by OpenDevice
  126.         io_Command      CMD_READ (02)
  127.         io_Flags        If IOF_QUICK is set, driver will attempt Quick IO
  128.         io_Length       number of characters to receive.
  129.         io_Data         pointer where to put the data.
  130.  
  131.    RESULTS
  132.         io_Error -- if the Read succeded, then io_Error will be null.
  133.             If the Read failed, then io_Error will contain an error code.
  134.  
  135.    BUGS
  136.         This function is not implemented yet.
  137.  
  138.    SEE ALSO
  139.         ioblixpar.device/PDCMD_SETPARAMS
  140.  
  141.  
  142. ioblixpar.device/CMD_RESET                           ioblixpar.device/CMD_RESET
  143.  
  144.    NAME
  145.         Reset -- reinitializes the parallel device
  146.  
  147.    FUNCTION
  148.         This command resets the parallel device to its freshly initialized
  149.         condition. It aborts all I/O requests both queued and current and
  150.         sets the devices's flags and parameters to their boot-up time 
  151.         default values. At boot-up time the PTermArray is random, and it
  152.         will be so also here.
  153.  
  154.    IO REQUEST
  155.         io_Message      mn_ReplyPort initialized
  156.         io_Device       set by OpenDevice
  157.         io_Unit         set by OpenDevice
  158.         io_Command      CMD_RESET (01)
  159.  
  160.    RESULTS
  161.         Error -- if the Reset succeded, then io_Error will be null.
  162.                  if the Reset failed, then the io_Error will be non-zero.
  163.  
  164.  
  165. ioblixpar.device/CMD_START                           ioblixpar.device/CMD_START
  166.  
  167.    NAME
  168.         Start -- restart paused I/O over the parallel port
  169.  
  170.    FUNCTION
  171.         This command restarts the current I/O activity on the parallel
  172.         port by reactivating the handshaking sequence.
  173.  
  174.    IO REQUEST
  175.         io_Message      mn_ReplyPort initialized
  176.         io_Device       set by OpenDevice
  177.         io_Unit         set by OpenDevice
  178.         io_Command      CMD_START (07)
  179.  
  180.    SEE ALSO
  181.         ioblixpar.device/CMD_STOP
  182.  
  183.  
  184. ioblixpar.device/CMD_STOP                             ioblixpar.device/CMD_STOP
  185.  
  186.    NAME
  187.         Stop -- pause current activity on the parallel device
  188.  
  189.    FUNCTION
  190.         This command halts the current I/O activity on the parallel
  191.         device by discontinuing the handshaking sequence. The stop and
  192.         start commands may not be nested.
  193.  
  194.    IO REQUEST
  195.         io_Message      mn_ReplyPort initialized
  196.         io_Device       set by OpenDevice
  197.         io_Unit         set by OpenDevice
  198.         io_Command      CMD_STOP (06)
  199.  
  200.    SEE ALSO
  201.         ioblixpar.device/CMD_START
  202.  
  203.  
  204. ioblixpar.device/CMD_WRITE                           ioblixpar.device/CMD_WRITE
  205.  
  206.    NAME
  207.         Write -- send output to parallel port
  208.  
  209.    FUNCTION
  210.         This command causes a stream of characters to be written to the
  211.         parallel output register. The number of characters is specified in
  212.         io_Length, unless -1 is used, in which case output is sent until
  213.         a zero byte occurs in the data. This is independent of, and may be
  214.         used simultaneously with setting the EOFMODE in io_ParFlags and using
  215.         the PTermArray to terminate the read or write.
  216.  
  217.    IO REQUEST
  218.         io_Message      mn_ReplyPort initialized
  219.         io_Device       set by OpenDevice
  220.         io_Unit         set by OpenDevice
  221.         io_Command      CMD_WRITE (03)
  222.         io_Flags        If IOF_QUICK is set, driver will attempt Quick IO
  223.         io_Length       number of characters to transmit, or if set
  224.                         to -1 send until zero byte encountered
  225.         io_Data         pointer to block of data to transmit
  226.  
  227.    RESULTS
  228.         io_Error -- If the Write succeded, then io_Error will be null.
  229.              If the Write failed, then io_Error will contain an error code.
  230.  
  231.    SEE ALSO
  232.         ioblixpar.device/PDCMD_SETPARAMS
  233.  
  234.  
  235. ioblixpar.device/FreeECPInfo                       ioblixpar.device/FreeECPInfo
  236.  
  237.    NAME
  238.        FreeECPInfo -- free the IEEE1284 probing information
  239.  
  240.    SYNOPSIS
  241.        FreeECPInfo(epi)
  242.                   A0
  243.  
  244.        void FreeECPInfo( struct ECPProbeInformation * );
  245.  
  246.    FUNCTION
  247.        Free the gathered ECP probing information again. Each AllocECPInfo()
  248.        call should be balanced by exactly one FreeECPInfo() call to avoid
  249.        memory leaks.
  250.  
  251.    INPUTS
  252.        epi - pointer to a previously allocated ECP information block. Passing
  253.              NULL is a no-op.
  254.  
  255.    SEE ALSO
  256.        AllocECPInfo
  257.  
  258.  
  259. ioblixpar.device/GetChipInfo                       ioblixpar.device/GetChipInfo
  260.  
  261.    NAME
  262.        GetChipInfo -- get the chip's information block
  263.  
  264.    SYNOPSIS
  265.        chipInfo = GetChipInfo(ioRequest)
  266.        D0                     A0
  267.  
  268.        struct IOBlixChipNode *GetChipInfo(struct IORequest *);
  269.  
  270.    FUNCTION
  271.        Get the chip's information block, as it is returned by
  272.        ioblix.resource/ObtainChip() and ioblix.resource/FindChip(). All fields
  273.        are considered READ-ONLY, you must not change anything.
  274.  
  275.    INPUTS
  276.        ioRequest        - pointer to a valid ioRequest after a successfull
  277.                           OpenDevice() call.
  278.  
  279.    RESULTS
  280.        chipInfo  - the chip's information block
  281.  
  282.    SEE ALSO
  283.        ioblix.resource/ObtainChip, ioblix.resource/FindChip
  284.  
  285.  
  286. ioblixpar.device/OpenDevice                         ioblixpar.device/OpenDevice
  287.  
  288.    NAME
  289.         Open -- a request to open the parallel port
  290.  
  291.    SYNOPSIS
  292.         error = OpenDevice("ioblixpar.device", unit, ioExtPar, flags)
  293.         D0                  A0                 D0    A1        D1
  294.  
  295.    FUNCTION
  296.         This function allows the requestor software access to the parallel
  297.         device.  Unless the shared-access bit (bit 5 of io_ParFlags) is
  298.         set, exclusive use is granted and no other access is allowed
  299.         until the owner closes the device.
  300.  
  301.         The PTermArray of the ioExtPar is initialized only if the EOFMODE
  302.         bit (bit 1 of io_ParFlags) is set. The PTermArray can be further
  303.         modified using the PDCMD_SETPARAMS command.
  304.  
  305.    INPUTS
  306.         "ioblixpar.device" - a pointer to literal string "ioblixpar.device"
  307.         unit - Must be zero for future compatibility
  308.         ioExtPar - pointer to an IO Request block of structure IOExtPar to
  309.                    be initialized by the Open() function. The io_ParFlags
  310.                    field must be set as desired.
  311.         flags - Must be zero for future compatibility
  312.  
  313.    RESULTS
  314.         d0 -- same as io_Error
  315.         io_Error -- if the Open succeded, then io_Error will be null.
  316.                     If the Open failed, then io_Error will be non-zero.
  317.  
  318.    SEE ALSO
  319.         exec/CloseDevice
  320.  
  321.  
  322. ioblixpar.device/PDCMD_QUERY                       ioblixpar.device/PDCMD_QUERY
  323.  
  324.    NAME
  325.         Query -- query parallel port/line status
  326.  
  327.    FUNCTION
  328.         This command return the status of the parallel port lines and
  329.         registers. 
  330.  
  331.    IO REQUEST
  332.         io_Message      must have mn_ReplyPort initialized
  333.         io_Device       set by OpenDevice
  334.         io_Unit         set by OpenDevice
  335.         io_Command      PDCMD_QUERY (09)
  336.  
  337.    RESULTS
  338.         io_Status        BIT  ACTIVE  FUNCTION
  339.  
  340.                          0     high   printer busy toggle (offline)
  341.                          1     high   paper out
  342.                          2     high   printer selected
  343.                          3      -     read=0,write=1
  344.                        4-7            reserved
  345.  
  346.  
  347. ioblixpar.device/PDCMD_SETPARAMS               ioblixpar.device/PDCMD_SETPARAMS
  348.  
  349.    NAME
  350.         SetParams -- change parameters for the parallel device
  351.  
  352.    FUNCTION
  353.         This command allows the caller to change the EOFMODE parameter for
  354.         the parallel port device. It will disallow changes if any reads or
  355.         writes are active or queued.  
  356.  
  357.         The PARB_EOFMODE bit of io_ParFlags controlls whether the
  358.         io_PTermArray is to be used as an additional termination criteria
  359.         for reads and writes.  It may be set directly without a call to
  360.         SetParams, setting it here performs the additional service of
  361.         copying the PTermArray into the device default array which is used
  362.         as the initial array for subsequent device opens. The Shared bit
  363.         can be changed here, and overrides the current device access mode
  364.         set at OpenDevice time.
  365.  
  366.    IO REQUEST
  367.         io_Message      mn_ReplyPort initialized
  368.         io_Device       preset by OpenDevice
  369.         io_Unit         preset by OpenDevice
  370.         io_Command      PDCMD_SETPARAMS (0A)
  371.                         NOTE that the following fields of your IORequest
  372.                         are filled by Open to reflect the parallel device's
  373.                         current configuration.
  374.         io_PExtFlags    must be set to zero, unless used
  375.         io_ParFlags     see definition in parallel.i or parallel.h
  376.                         NOTE that x00 yields exclusive access, PTermArray
  377.                         inactive.
  378.         io_PTermArray   ASCII descending-ordered 8-byte array of
  379.                         termination characters. If less than 8 chars
  380.                         used, fill out array w/lowest valid value.
  381.                         Terminators are used only if EOFMODE bit of
  382.                         io_Parflags is set. (e.g. x512F040303030303 )
  383.                         This field is filled on OpenDevice only if the
  384.                         EOFMODE bit is set.
  385.  
  386.    RESULTS
  387.         io_Error -- if the SetParams succeded, then io_Error will be null.
  388.                     if the SetParams failed, then io_Error will be non-zero.
  389.  
  390.  
  391.  
  392.